from rest_framework import serializers
from apps.homepage.models import ZtTask, ZtUser, ZtTaskTeam

#需求列表信息序列化
class ZtTaskGanttSerializer(serializers.ModelSerializer):

    class Meta:
        model = ZtTask
        fields = ['id', 'name', 'status', 'estStarted', 'deadline', 'realStarted','finishedDate']

    def get_translated_fields(self, obj):
        '''
        转换字段
        '''

        #转换关系
        status_map = {
            'wait': '未开始',
            'doing': '进行中',
            'done': '已完成',
            'pause': '进行中',
            'cancel': '进行中',
            'closed': '已完成',
        }

        # 定义一个字典，键是字段名，值是转换函数
        translations = {
            'status': lambda value: status_map[value],
        }

        # 获取原始值
        original_values = {field_name: getattr(obj, field_name) for field_name in translations}

        # 应用转换
        translated_values = {field_name: translations[field_name](original_value) for field_name, original_value in
                             original_values.items()}

        return translated_values

    def to_representation(self, instance):
        '''
        更新为转换后的值
        '''
        # 获取转换后的值
        translated_values = self.get_translated_fields(instance)

        # 将转换后的值添加到原始序列化器的数据中
        data = super(ZtTaskGanttSerializer, self).to_representation(instance)
        data.update(translated_values)

        return data

class ZtUserSerializer(serializers.ModelSerializer):
    class Meta:
        model = ZtUser
        fields = ('realname','account',)

class ZtTaskTeamSerializer(serializers.ModelSerializer):
    account = ZtUserSerializer(read_only=True)

    class Meta:
        model = ZtTaskTeam
        fields = ('account',)

#需求列表信息序列化
class ZtTaskListSerializer(serializers.ModelSerializer):

    # 获取模块名
    module_name = serializers.SerializerMethodField()
    # 获取指派人的真实姓名
    assignedTo_realname = serializers.SerializerMethodField()
    #获取需求名称
    story_name = serializers.SerializerMethodField()
    #获取版本（所属执行）名称
    execution_name = serializers.SerializerMethodField()

    class Meta:
        model = ZtTask
        fields = ['id', 'name', 'status', 'estStarted', 'deadline', 'realStarted','finishedDate',
                  'assignedTo_realname', 'assignedTo', 'execution_name', 'module_name', 'story_name', 'pri', 'mode']

    def get_module_name(self, obj):
        '''
        获取module对应的名称
        '''

        # 获取关联的ZtModule对象
        try:
            module = obj.module
        except:
            # module字段为空（没有PM字段）
            return ''
        # 如果存在关联的User对象，则返回其realname，否则返回None
        return module.name if module else ''

    def get_assignedTo_realname(self, obj):
        '''
        获取module对应的名称
        '''

        # 获取关联的ZtUser对象
        try:
            assignedTo = obj.assignedTo
        except:
            # module字段为空（没有PM字段）
            return ''
        # 如果存在关联的User对象，则返回其realname，否则返回None
        return assignedTo.realname if assignedTo else ''

    def get_story_name(self, obj):
        '''
        获取story对应的名称
        '''

        # 获取关联的ZtModule对象
        try:
            story = obj.story
        except:
            # module字段为空（没有PM字段）
            return ''
        # 如果存在关联的User对象，则返回其realname，否则返回None
        return story.title if story else ''

    def get_execution_name(self, obj):
        '''
        获取execution对应的名称
        '''

        # 获取关联的ZtUser对象
        try:
            execution = obj.execution
        except:
            # module字段为空（没有PM字段）
            return ''
        # 如果存在关联的User对象，则返回其realname，否则返回None
        return execution.name if execution else ''

    def get_translated_fields(self, obj):
        '''
        转换字段
        '''

        #转换关系
        status_map = {
            'wait': '未开始',
            'doing': '进行中',
            'done': '已完成',
            'pause': '进行中',
            'cancel': '进行中',
            'closed': '已完成',
        }

        # 定义一个字典，键是字段名，值是转换函数
        translations = {
            'status': lambda value: status_map[value],
        }

        # 获取原始值
        original_values = {field_name: getattr(obj, field_name) for field_name in translations}

        # 应用转换
        translated_values = {field_name: translations[field_name](original_value) for field_name, original_value in
                             original_values.items()}

        return translated_values

    def to_representation(self, instance):
        '''
        更新为转换后的值
        '''
        # 获取转换后的值
        translated_values = self.get_translated_fields(instance)

        # 将转换后的值添加到原始序列化器的数据中
        data = super(ZtTaskListSerializer, self).to_representation(instance)
        data.update(translated_values)

        # 预先获取所有相关数据，减少数据库查询次数
        taskteams = instance.taskteam_task.all().prefetch_related('account')
        data['taskteam'] = ZtTaskTeamSerializer(taskteams, many=True).data

        return data

#需求列表信息序列化
class ZtTaskDetailSerializer(serializers.ModelSerializer):

    # 获取模块名
    module_name = serializers.SerializerMethodField()
    # 获取指派人的真实姓名
    assignedTo_realname = serializers.SerializerMethodField()
    #获取需求名称
    story_name = serializers.SerializerMethodField()
    #获取版本（所属执行）名称
    execution_name = serializers.SerializerMethodField()

    class Meta:
        model = ZtTask
        fields = ['id', 'name', 'status', 'estStarted', 'deadline', 'realStarted','finishedDate','assignedTo_realname',
                  'assignedTo', 'execution_name', 'module_name', 'story_name', 'pri', 'mode', 'desc']

    def get_module_name(self, obj):
        '''
        获取module对应的名称
        '''

        # 获取关联的ZtModule对象
        try:
            module = obj.module
        except:
            # module字段为空（没有PM字段）
            return ''
        # 如果存在关联的User对象，则返回其realname，否则返回None
        return module.name if module else ''

    def get_assignedTo_realname(self, obj):
        '''
        获取module对应的名称
        '''

        # 获取关联的ZtUser对象
        try:
            assignedTo = obj.assignedTo
        except:
            # module字段为空（没有PM字段）
            return ''
        # 如果存在关联的User对象，则返回其realname，否则返回None
        return assignedTo.realname if assignedTo else ''

    def get_story_name(self, obj):
        '''
        获取story对应的名称
        '''

        # 获取关联的ZtModule对象
        try:
            story = obj.story
        except:
            # module字段为空（没有PM字段）
            return ''
        # 如果存在关联的User对象，则返回其realname，否则返回None
        return story.title if story else ''

    def get_execution_name(self, obj):
        '''
        获取execution对应的名称
        '''

        # 获取关联的ZtUser对象
        try:
            execution = obj.execution
        except:
            # module字段为空（没有PM字段）
            return ''
        # 如果存在关联的User对象，则返回其realname，否则返回None
        return execution.name if execution else ''

    def get_translated_fields(self, obj):
        '''
        转换字段
        '''

        #转换关系
        status_map = {
            'wait': '未开始',
            'doing': '进行中',
            'done': '已完成',
            'pause': '进行中',
            'cancel': '进行中',
            'closed': '已完成',
        }

        # 定义一个字典，键是字段名，值是转换函数
        translations = {
            'status': lambda value: status_map[value],
        }

        # 获取原始值
        original_values = {field_name: getattr(obj, field_name) for field_name in translations}

        # 应用转换
        translated_values = {field_name: translations[field_name](original_value) for field_name, original_value in
                             original_values.items()}

        return translated_values

    def to_representation(self, instance):
        '''
        更新为转换后的值
        '''
        # 获取转换后的值
        translated_values = self.get_translated_fields(instance)

        # 将转换后的值添加到原始序列化器的数据中
        data = super(ZtTaskDetailSerializer, self).to_representation(instance)
        data.update(translated_values)

        # 预先获取所有相关数据，减少数据库查询次数
        taskteams = instance.taskteam_task.all().prefetch_related('account')
        data['taskteam'] = ZtTaskTeamSerializer(taskteams, many=True).data

        return data